package com.jvyou.common.utils.array;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Objects;

public class ArrayUtils {

    /**
     * 将 Byte[] 转换为 byte[]
     *
     * @param array 包装类型数组，可以为 null
     * @return 基本类型数组，输入为 null 时返回 null
     * @throws NullPointerException 如果数组包含 null 元素
     */
    public static byte[] toPrimitive(Byte[] array) {
        if (array == null) {
            return null;
        }
        if (array.length == 0) {
            return new byte[0];
        }

        byte[] result = new byte[array.length];
        for (int i = 0; i < array.length; i++) {
            result[i] = Objects.requireNonNull(array[i], "Array element cannot be null");
        }
        return result;
    }

    /**
     * 带默认值的转换方法
     *
     * @param array        包装类型数组
     * @param valueForNull 用于替换 null 的默认值
     * @return 基本类型数组
     */
    public static byte[] toPrimitive(Byte[] array, byte valueForNull) {
        if (array == null) {
            return null;
        }
        if (array.length == 0) {
            return new byte[0];
        }

        byte[] result = new byte[array.length];
        for (int i = 0; i < array.length; i++) {
            result[i] = (array[i] != null ? array[i] : valueForNull);
        }
        return result;
    }

    /**
     * 合并两个数组
     *
     * @param array1 第一个数组 (可以为null)
     * @param array2 第二个数组 (可以为null)
     * @param <T>    数组元素类型
     * @return 合并后的新数组
     * @throws IllegalArgumentException 如果数组类型不兼容
     */
    @SuppressWarnings("unchecked")
    public static <T> T[] addAll(final T[] array1, final T... array2) {
        // 处理两个数组都为null的情况
        if (array1 == null && array2 == null) {
            return null;
        }

        // 处理其中一个数组为null的情况
        if (array1 == null) {
            return Arrays.copyOf(array2, array2.length);
        }
        if (array2 == null) {
            return Arrays.copyOf(array1, array1.length);
        }

        // 检查数组类型是否兼容
        Class<?> type1 = array1.getClass().getComponentType();
        Class<?> type2 = array2.getClass().getComponentType();
        if (!type1.isAssignableFrom(type2)) {
            throw new IllegalArgumentException("Cannot merge arrays of incompatible types: " +
                    type1.getName() + " and " + type2.getName());
        }

        // 创建合并后的数组
        T[] mergedArray = (T[]) Array.newInstance(type1, array1.length + array2.length);

        // 拷贝数组元素
        System.arraycopy(array1, 0, mergedArray, 0, array1.length);
        System.arraycopy(array2, 0, mergedArray, array1.length, array2.length);

        return mergedArray;
    }

    /**
     * 基本类型数组合并的示例实现 (以int[]为例)
     */
    public static int[] addAllInt(final int[] array1, final int... array2) {
        if (array1 == null) {
            return array2 != null ? Arrays.copyOf(array2, array2.length) : null;
        }
        if (array2 == null) {
            return Arrays.copyOf(array1, array1.length);
        }

        int[] merged = new int[array1.length + array2.length];
        System.arraycopy(array1, 0, merged, 0, array1.length);
        System.arraycopy(array2, 0, merged, array1.length, array2.length);
        return merged;
    }
}